home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Format CD 52
/
Amiga Format AFCD52 (Issue 136, May 2000).iso
/
-serious-
/
programming
/
other
/
dopus412-gpl
/
program
/
main5.c
< prev
next >
Wrap
C/C++ Source or Header
|
2000-02-28
|
11KB
|
478 lines
/*
Directory Opus 4
Original GPL release version 4.12
Copyright 1993-2000 Jonathan Potter
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
All users of Directory Opus 4 (including versions distributed
under the GPL) are entitled to upgrade to the latest version of
Directory Opus version 5 at a reduced price. Please see
http://www.gpsoft.com.au for more information.
The release of Directory Opus 4 under the GPL in NO WAY affects
the existing commercial status of Directory Opus 5.
*/
#include "dopus.h"
#include "asyncio.h"
copyfile(src,dst,err,size,password,encryptstate)
char *src,*dst;
int *err,size;
char *password;
int encryptstate;
{
char *buffer;
struct FileInfoBlock __aligned cfinfo;
int out,length,suc,readsize,size_read,size_write,size_total,ret=0,prog=0,buffer_size;
int inhandle;
int outhandle;
struct AsyncFile *infile;
/*
struct AsyncFile *outfile;
*/
struct DateStamp ds,*dsp;
ULONG owner_info;
buffer=NULL;
infile=NULL;
/*
outfile=NULL;
*/
inhandle=0;
outhandle=0;
if (password) {
int a,encrypt=1;
for (a=0;password[a];a++) encrypt*=password[a];
Seed(encrypt);
}
if (config->dynamicflags&UPDATE_PROGRESSIND_COPY) prog=1;
suc=lockandexamine(src,&cfinfo);
if (size==0) {
if (suc) {
if (cfinfo.fib_Size==0) {
if ((out=Open(dst,MODE_NEWFILE))) Close(out);
else goto failed;
}
if (config->copyflags©_DATE) setdate(dst,&(cfinfo.fib_Date));
if (config->copyflags©_PROT) SetProtection(dst,cfinfo.fib_Protection);
if (config->copyflags©_NOTE) SetComment(dst,cfinfo.fib_Comment);
if (system_version2) {
owner_info=(cfinfo.fib_OwnerUID<<16)|cfinfo.fib_OwnerGID;
if (owner_info) SetOwner(dst,owner_info);
}
}
filloutcopydatafile(dst);
if (suc) return(1);
}
if (!suc) {
*err=IoErr();
return(0);
}
if (!(size=cfinfo.fib_Size)) {
if (!(out=Open(dst,MODE_NEWFILE))) goto failed;
Close(out);
return(1);
}
if (size<=COPY_BUF_SIZE) {
dotaskmsg(hotkeymsg_port,PROGRESS_UPDATE,100,100,NULL,1);
prog=0;
}
else dotaskmsg(hotkeymsg_port,PROGRESS_UPDATE,0,100,NULL,1);
/*
if (prog) {
buffer_size=COPY_BUF_SIZE;
buffer=AllocMem(COPY_BUF_SIZE,0);
if (infile=OpenAsync(src,MODE_READ,ASYNC_READ_SIZE))
outfile=OpenAsync(dst,MODE_WRITE,ASYNC_WRITE_SIZE);
if (!outfile) goto failed;
}
else {
if (size>65536) buffer_size=size/2;
else buffer_size=size;
if (buffer_size>122880) buffer_size=122880;
while (buffer_size>0) {
if (buffer=AllocMem(buffer_size,0)) break;
buffer_size/=2;
}
if (inhandle=Open(src,MODE_OLDFILE))
outhandle=Open(dst,MODE_NEWFILE);
if (!outhandle) goto failed;
}
if (!buffer) goto failed;
*/
if (prog) {
buffer_size=2048;
infile=OpenAsync(src,MODE_READ,ASYNC_READ_SIZE);
}
else {
if (size>65536) buffer_size=size/2;
else buffer_size=size;
if (buffer_size>122880) buffer_size=122880;
}
while (buffer_size>0) {
if (buffer=AllocMem(buffer_size,0)) break;
buffer_size/=2;
}
if (!buffer) goto failed;
if (!infile && (!(inhandle=Open(src,MODE_OLDFILE)))) goto failed;
if (!(outhandle=Open(dst,MODE_NEWFILE))) goto failed;
DateStamp(&ds);
size_read=size_write=0;
size_total=size*2;
while (size>0) {
readsize=(size>buffer_size)?buffer_size:size;
if (infile) length=ReadAsync(infile,buffer,readsize);
else length=Read(inhandle,buffer,readsize);
size-=readsize;
size_read+=length;
if (prog)
dotaskmsg(hotkeymsg_port,PROGRESS_UPDATE,size_read+size_write,size_total,NULL,1);
if (status_haveaborted) {
ret=-1;
goto failed;
}
if (password) {
int a;
char enbyte;
if (encryptstate) {
for (a=0;a<length;a++) {
enbyte=Random(9999);
buffer[a]+=enbyte;
}
}
else {
for (a=0;a<length;a++) {
enbyte=Random(9999);
buffer[a]-=enbyte;
}
}
}
if (length>0) {
/*
if (outfile) {
if ((WriteAsync(outfile,buffer,length))==-1) goto failed;
}
else
*/
if ((Write(outhandle,buffer,length))==-1) goto failed;
}
size_write+=length;
if (prog)
dotaskmsg(hotkeymsg_port,PROGRESS_UPDATE,size_read+size_write,size_total,NULL,1);
if (status_haveaborted) {
ret=-1;
goto failed;
}
}
if (infile) CloseAsync(infile);
/*
if (outfile) CloseAsync(outfile);
*/
if (inhandle) Close(inhandle);
if (outhandle) Close(outhandle);
FreeMem(buffer,buffer_size);
if (config->copyflags©_DATE) {
setdate(dst,&(cfinfo.fib_Date));
dsp=&cfinfo.fib_Date;
}
else dsp=&ds;
copy_datestamp(dsp,&dos_copy_date);
if (config->copyflags©_PROT) SetProtection(dst,cfinfo.fib_Protection);
dos_copy_protection=cfinfo.fib_Protection;
if (config->copyflags©_NOTE) {
SetComment(dst,cfinfo.fib_Comment);
strcpy(dos_copy_comment,cfinfo.fib_Comment);
}
else dos_copy_comment[0]=0;
return(1);
failed:
*err=IoErr();
if (buffer) FreeMem(buffer,buffer_size);
if (infile) CloseAsync(infile);
if (inhandle) Close(inhandle);
if (/* outfile || */ outhandle) {
/*
if (outfile) CloseAsync(outfile);
else
*/
Close(outhandle);
DeleteFile(dst);
}
return(ret);
}
struct Directory *checktot(dir)
struct DirectoryWindow *dir;
{
struct Directory *first;
if (!dir) return(NULL);
first=dir->firstentry;
while (first) {
if (first->selected && first->type<=ENTRY_FILE) break;
first=first->next;
}
return(first);
}
struct Directory *checkdirtot(dir)
struct DirectoryWindow *dir;
{
struct Directory *first;
if (!dir) return(NULL);
first=dir->firstentry;
while (first) {
if (first->selected && ENTRYTYPE(first->type)==ENTRY_DIRECTORY) break;
first=first->next;
}
return(first);
}
struct Directory *checkdevtot(dir)
struct DirectoryWindow *dir;
{
struct Directory *first;
if (!dir) return(NULL);
first=dir->firstentry;
while (first) {
if (first->selected && first->type==ENTRY_DEVICE) break;
first=first->next;
}
return(first);
}
struct Directory *checkalltot(dir)
struct DirectoryWindow *dir;
{
struct Directory *first;
if (!dir) return(NULL);
first=dir->firstentry;
while (first) {
if (first->selected && first->type!=ENTRY_DEVICE && first->type!=ENTRY_CUSTOM) break;
first=first->next;
}
return(first);
}
struct Directory *findfile(dir,name,count)
struct DirectoryWindow *dir;
char *name;
int *count;
{
struct Directory *find;
/*
char parsebuf[100];
LParsePatternI(name,parsebuf);
*/
if (dir) {
find=dir->firstentry;
if (count) *count=0;
while (find) {
/*
if (find->name && (LMatchPatternI(parsebuf,find->name))) return(find);
*/
if (find->name && !(LStrCmpI(name,find->name))) return(find);
find=find->next;
if (count) ++(*count);
}
}
return(NULL);
}
delfile(name,nam,errs,unprotect,errcheck)
char *name,*nam,*errs;
int unprotect,errcheck;
{
int suc,a,err,try=0,recplus=0;
char buf[300],buf2[100];
loop:
suc=DeleteFile(name);
if (!suc) {
if ((err=IoErr())==ERROR_OBJECT_NOT_FOUND) suc=1;
else {
if (err==ERROR_DIRECTORY_NOT_EMPTY) return(-2);
else if (err==ERROR_DELETE_PROTECTED && try==0) {
if (!(config->deleteflags&DELETE_SET)) {
if (!unprotect) {
doerror(ERROR_DELETE_PROTECTED);
geterrorstring(buf2,ERROR_DELETE_PROTECTED);
lsprintf(buf,globstring[STR_ERROR_OCCURED],globstring[STR_DELETING],nam,buf2);
strcat(buf,globstring[STR_SELECT_UNPROTECT]);
if (!(a=simplerequest(buf,globstring[STR_UNPROTECT],
globstring[STR_ABORT],globstring[STR_UNPROTECT_ALL],globstring[STR_SKIP],NULL)))
return(-1);
if (a==3) return(0);
if (a==2) recplus=1;
}
}
try=1;
SetProtection(name,0);
goto loop;
}
else if (!errcheck) return(-2);
doerror(err);
if ((a=checkerror(errs,nam,err))==3) return(-1);
if (a==1) goto loop;
}
}
else {
if (recplus) suc=2;
else suc=1;
}
return(suc);
}
getwildrename(sname,dname,name,newn)
char *sname,*dname,*name,*newn;
{
char sfirst[40],slast[40],dfirst[40],dlast[40],foon[40];
int a,b,c,flen,llen,d;
b=strlen(sname); sfirst[0]=slast[0]=0;
for (a=0;a<b;a++)
if (sname[a]=='*') {
strcpy(sfirst,sname); sfirst[(flen=a)]=0;
strcpy(slast,(char *)&sname[a+1]);
llen=b-a;
break;
}
b=strlen(dname);
for (a=0;a<b;a++)
if (dname[a]=='*') {
strcpy(dfirst,dname); dfirst[a]=0;
strcpy(dlast,(char *)&dname[a+1]);
break;
}
a=strlen(sfirst); b=strlen(slast);
if ((!a || (LStrnCmpI(name,sfirst,flen))==0) &&
(!b || ((d=strlen(name))>=llen && (LStrCmpI(&name[(d-llen)+1],slast))==0))) {
c=strlen(name)-a-b;
CopyMem((char *)&name[a],foon,c);
foon[c]=0;
strcpy(newn,dfirst); strcat(newn,foon); strcat(newn,dlast);
if (newn[0]!=0) return(1);
}
return(0);
}
void filloutcopydata(dir)
struct Directory *dir;
{
dos_copy_date.ds_Days=dir->date.ds_Days;
dos_copy_date.ds_Minute=dir->date.ds_Minute;
dos_copy_date.ds_Tick=dir->date.ds_Tick;
dos_copy_protection=dir->protection;
if (dir->comment) strcpy(dos_copy_comment,dir->comment);
else dos_copy_comment[0]=0;
}
void filloutcopydatafile(fil)
char *fil;
{
struct FileInfoBlock __aligned fileinfo;
if (lockandexamine(fil,&fileinfo)) {
dos_copy_date.ds_Days=fileinfo.fib_Date.ds_Days;
dos_copy_date.ds_Minute=fileinfo.fib_Date.ds_Minute;
dos_copy_date.ds_Tick=fileinfo.fib_Date.ds_Tick;
dos_copy_protection=fileinfo.fib_Protection;
strcpy(dos_copy_comment,fileinfo.fib_Comment);
}
}
void update_buffer_stamp(win,true)
int win,true;
{
struct FileInfoBlock __aligned fib;
char dirbuf[256];
struct DirectoryWindow *dirwin;
if (win==-1 || !(config->dirflags&DIRFLAGS_REREADOLD)) return;
dirwin=dopus_curwin[win];
strcpy(dirbuf,str_pathbuffer[win]);
FOREVER {
if (true) {
if (lockandexamine(dirbuf,&fib))
copy_datestamp(&fib.fib_Date,&dirwin->dirstamp);
if (!(doparent(dirbuf)) ||
!(dirwin=findbuffer(dirbuf,win,0,1))) break;
}
else {
if (!(dirwin=dirwin->next) ||
dirwin==dopus_curwin[win]) break;
if (LStrnCmpI(dirwin->directory,dirbuf,strlen(dirbuf))==0) {
dirwin->dirstamp.ds_Days=0;
dirwin->dirstamp.ds_Minute=0;
dirwin->dirstamp.ds_Tick=0;
}
}
}
}
check_key_press(func,code,qual)
struct dopusfunction *func;
USHORT code,qual;
{
if (!func->function ||
!func->function[0] ||
(func->key==0xff && func->qual==0) ||
func->key==0 ||
func->qual!=qual) return(0);
if (func->key==0xff || func->key==code) return(1);
return(0);
}